package com.deuwise.common.base;
import com.deuwise.common.utils.SpringContextHolder;
import com.deuwise.system.entity.from.PassConfigForm;
import com.deuwise.system.service.ConfigDoService;
import org.apache.commons.lang3.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 账户相关属性验证工具
 *
 */
/**
 * Copyright
 *
 * @author chenwenchao
 * @date 2019/1/25 0025
 * Description:
 */
public class AccountValidatorUtil {
    /**
     * 正则表达式：验证用户名
     */
    public static final String REGEX_USERNAME = "^[a-zA-Z]\\w{5,20}$";

    /**
     * 正则表达式：验证密码
     */
    public static final String REGEX_PASSWORD = "^[a-zA-Z0-9]{6,20}$";

    /**
     * 正则表达式：验证必须包含小写字母
     */
    public static final String REGEX_LOWERCASE="[a-z]";

    /**
     * 正则表达式：验证必须包含大写字母
     */
    public static final String REGEX_UPPERCASE="[A-Z]";

    /**
     * 正则表达式：验证必须包含特殊字符
     */
    public static  final  String REGEX_SPECIAL="[^\\w\\s]+";

    /**
     * 正则表达式：验证必须包含数字
     */
    public static  final  String REGEX_NUM="[0-9]";

    /**
     * 正则表达式：验证手机号
     */
    public static final String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";

    /**
     * 正则表达式：验证邮箱
     */
    public static final String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";

    /**
     * 正则表达式：验证汉字
     */
    public static final String REGEX_CHINESE = "^[\u4e00-\u9fa5],{0,}$";

    /**
     * 正则表达式：验证身份证
     */
    public static final String REGEX_ID_CARD = "(^\\d{18}$)|(^\\d{15}$)";

    /**
     * 正则表达式：验证URL
     */
    public static final String REGEX_URL = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";

    /**
     * 正则表达式：验证IP地址
     */
    public static final String REGEX_IP_ADDR = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";

    /**
     * 校验用户名
     *
     * @param username
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isUsername(String username) {
        return Pattern.matches(REGEX_USERNAME, username);
    }

    /**
     * 校验密码
     *
     * @param password
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isPassword(String password) {
        return Pattern.matches(REGEX_PASSWORD, password);
    }

    /**
     * 校验手机号
     *
     * @param mobile
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isMobile(String mobile) {
        return Pattern.matches(REGEX_MOBILE, mobile);
    }

    /**
     * 校验邮箱
     *
     * @param email
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isEmail(String email) {
        return Pattern.matches(REGEX_EMAIL, email);
    }

    /**
     * 校验汉字
     *
     * @param chinese
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isChinese(String chinese) {
        return Pattern.matches(REGEX_CHINESE, chinese);
    }

    /**
     * 校验身份证
     *
     * @param idCard
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isIDCard(String idCard) {
        return Pattern.matches(REGEX_ID_CARD, idCard);
    }

    /**
     * 校验URL
     *
     * @param url
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isUrl(String url) {
        return Pattern.matches(REGEX_URL, url);
    }

    /**
     * 校验IP地址
     *
     * @param ipAddr
     * @return
     */
    public static boolean isIPAddr(String ipAddr) {
        return Pattern.matches(REGEX_IP_ADDR, ipAddr);
    }

    /**
     * 检验是否包含大写字母
     * @param upperCase
     * @return
     */
    public static  boolean includeUpperCase(String upperCase) {
        Pattern r = Pattern.compile(REGEX_UPPERCASE);
        Matcher m = r.matcher(upperCase);
        return  m.find();
    }

    /**
     * 检验是否包小写字母
     * @param lowerCase
     * @return
     */
    public static  boolean includeLowerCase(String lowerCase){
        Pattern r = Pattern.compile(REGEX_LOWERCASE);
        Matcher m = r.matcher(lowerCase);
        return  m.find();
    }

    /**
     * 检验是否包含特殊字符
     * @param special
     * @return
     */
    public static  boolean includeSpecial(String special){
        Pattern r = Pattern.compile(REGEX_SPECIAL);
        Matcher m = r.matcher(special);
        return  m.find();
    }

    /**
     * 检验是否包含数字
     * @param num
     * @return
     */
    public static  boolean includeNum(String num){
        Pattern r = Pattern.compile(REGEX_NUM);
        Matcher m = r.matcher(num);
        return  m.find();
    }

    /**
     * 验证密码强度操作类
     * @param passWord
     * @param alertInfo
     * @return
     */
    public static  boolean validatorPass(String passWord,StringBuffer alertInfo) {
        boolean pass = true;
        ConfigDoService configDoService = SpringContextHolder.getBean(ConfigDoService.class);
        PassConfigForm passConfigForm = configDoService.getPassWordConfig();
        boolean secondTag=false;
        String andTag="";
        if (passConfigForm.isCheck()) {
            if(StringUtils.isNotBlank(passConfigForm.getPassWordLen())){
                Integer len=Integer.parseInt(passConfigForm.getPassWordLen());
                if(passWord.length()<len||passWord.length()>20){
                    alertInfo.append(len+ "-20位字符、");
                    secondTag=true;
                    pass=false;
                }
            }else{

            }if(passWord.length()>20){
                if(secondTag){
                    andTag="和";
                    secondTag=false;
                }else{
                    secondTag=true;
                }
                alertInfo.append(andTag+"20位内字符、");
                pass=false;
                if(!secondTag){
                    andTag="";
                }
            }
            if (passConfigForm.isIncludeNum()) {

                if (!AccountValidatorUtil.includeNum(passWord)) {
                    if(secondTag){
                        andTag="和";
                        secondTag=false;
                    }else{
                        secondTag=true;
                    }
                    alertInfo.append(andTag+"数字、");
                    pass = false;
                    if(!secondTag){
                        andTag="";
                    }
                }
            }
            if (passConfigForm.isIncludeLowerCase()) {
                if(secondTag){
                    andTag="和";
                    secondTag=false;
                }else{
                    secondTag=true;
                }
                if (!AccountValidatorUtil.includeLowerCase(passWord)) {
                    alertInfo.append(andTag+"小写字母、");
                    pass = false;
                }
                if(!secondTag){
                    andTag="";
                }
            }
            if (passConfigForm.isIncludeUpperCase()) {
                if(secondTag){
                    andTag="和";
                    secondTag=false;
                }else{
                    secondTag=true;
                }
                if (!AccountValidatorUtil.includeUpperCase(passWord)) {
                    alertInfo.append(andTag+"大写字母、");
                    pass = false;
                }
                if(secondTag){
                    andTag="";
                }
            }
            if (passConfigForm.isIncludeSpecial()) {
                if(secondTag){
                    andTag="和";
                    secondTag=false;
                }else{
                    secondTag=true;
                }
                if (!AccountValidatorUtil.includeSpecial(passWord)) {
                    alertInfo.append(andTag+"特殊字符、");
                    pass = false;
                }
                if(!secondTag){
                    andTag="";
                }
            }

        }
        return  pass;
    }

}
